import { IGaeaAll, IGaeaInstance } from '../../types';
// import { ComponentType } from '../constants/component-types';
import _ from 'lodash';
import { ICondition } from '../../types';
import ConditionHandlers, { defaultHandler } from '.';
import { ComponentExtraProperties } from '../constants/extra-properties';
import { isEmptyExecptZero } from '@/utils/utils';

// // 单选框解析
// const parseRadioSelect = (componentData: IGaeaInstance, value: string) => {
//   let options = componentData.data.props.options;
//   if (!options || !value) {
//     return '';
//   }
//   let item = options.find(el => el.value == value);
//   return item?.text;
// };
// // 多选框解析
// const parseMultiSelect = (componentData: IGaeaInstance, value: string[]) => {
//   let options = componentData.data.props.options;
//   if (!options || !value) {
//     return '';
//   }
//   let arr = options.filter(el => value.indexOf(el.value) != -1);
//   let tmp = arr.map(el => el.text);
//   return tmp.join('；');
// };

// 不同类型的处理
const Parser: IterateAny = {
  // [ComponentType.RadioSelect]: parseRadioSelect,
  // [ComponentType.CheckboxSelect]: parseMultiSelect,
};
const ValueParser: IterateAny = {
  // [ComponentType.RadioSelect]: parseRadioSelect,
  // [ComponentType.CheckboxSelect]: parseMultiSelect,
};

// 解析form表单的值
export const parseValue = (rawValue: string) => {
  try {
    const value = JSON.parse(rawValue);
    return value;
  } catch (error) {
    // console.error('form parse failed');
    return {};
  }
};

export const parseInstanceValue = (
  componentData: IGaeaInstance,
  value: any
) => {
  const parser = Parser[componentData.gaeaKey];
  // 没有对应解析器 则默认不用解析
  if (!parser) {
    return value;
  } else {
    return parser(componentData, value);
  }
};

// form表单和值合并
export const parseValueForDetail = (
  formParsed: IGaeaAll,
  formValueParsed: IterateAny
) => {
  if (!formParsed) {
    return {};
  }
  let formParsedValues = {};
  Object.keys(formParsed).forEach((key) => {
    const code =
      formParsed[key]?.data?.props.customCode ||
      formParsed[key]?.data?.props.code;
    if (!code) return;
    formParsed[key].data.props.value = parseInstanceValue(
      formParsed[key],
      formValueParsed[code]
    );
    // todo ??
    if (formValueParsed[code]) {
      formParsedValues[key] = formValueParsed[code];
    }
  });
  return formParsedValues;
};

export const parseTextValue = (value: any, gaeaKey?: string, params?: any) => {
  if (
    _.isString(value) &&
    (value.indexOf('[') > -1 || value.indexOf('{') > -1)
  ) {
    try {
      value = JSON.parse(value);
    } catch (err) {
      console.error('parseTextValue fail');
    }
  }
  const parser = gaeaKey ? Parser[gaeaKey] : null;
  // 没有对应解析器 则默认不用解析
  if (!parser) {
    // 如果是对象
    if (_.isPlainObject(value)) {
      value = value.text || value.label || value.title;
    } else if (_.isArray(value)) {
      // 如果是对象数组
      const tmp = value.map((el: any) => {
        if (_.isObject(el)) {
          return el['text'] || el['label'] || el['title'];
        }
        return el;
      });
      value = tmp.join('，');
    }
    return value;
  } else {
    return parser(value, params);
  }
};

/**
 * 从所有的value中解析出value,
 * 方便排序，条件等操作
 * @param value
 * @param gaeaKey
 * @param params
 */
export const parseValueFromOirginValue = (
  value: any,
  gaeaKey?: string,
  params?: any
) => {
  if (
    _.isString(value) &&
    (value.indexOf('[') > -1 || value.indexOf('{') > -1)
  ) {
    try {
      value = JSON.parse(value);
    } catch (err) {
      console.error('parseTextValue fail');
    }
  }
  const parser = gaeaKey ? ValueParser[gaeaKey] : null;
  // 没有对应解析器 则默认不用解析
  if (!parser) {
    // 如果是对象
    if (_.isPlainObject(value)) {
      value = value.value;
    } else if (_.isArray(value)) {
      // 如果是对象数组
      const tmp = value.map((el: any) => {
        if (_.isObject(el)) {
          return el['value'];
        }
        return el;
      });
      tmp.sort();
      value = tmp.join('，');
    }
    return value;
  } else {
    return parser(value, params);
  }
};

export const parseConditionsValue = (values: any) => {
  if (!values) return undefined;
  const obj: IterateAny = {};
  for (const key in values) {
    obj[key] = parseValueFromOirginValue(values[key]);
  }
  return obj;
};

// activityId 如果是发起人：BPMN_APPLY_NODE_ID，全量：‘all’; 审批节点:'Activity_xxx'
export const parseFormData = (
  formData: string,
  activityId = 'all',
  readonly?: boolean
) => {
  let jsonParsed = {} as IGaeaAll;
  try {
    jsonParsed = JSON.parse(formData);
    if (!jsonParsed) return jsonParsed;
    // 如果是全量的权限 则不用赋值permission
    if (activityId === 'all') {
      return jsonParsed;
    }
    for (const key in jsonParsed) {
      // 非全量权限，根据传进来的activityId获取对应节点的权限
      if (jsonParsed[key].data.props.bpmnPermission) {
        // 如果 是只读模式，比如我已审批，把编辑权限变为只读，但是其他权限不变，比如隐藏
        if (
          readonly &&
          jsonParsed[key].data.props.bpmnPermission?.[activityId] === 'editable'
        ) {
          jsonParsed[key].data.props.permission = 'readonly';
        } else {
          jsonParsed[key].data.props.permission =
            jsonParsed[key].data.props.bpmnPermission?.[activityId];
        }
      }
    }
  } catch (error) {
    // message.error(config.abnormalStatus.FORMERROR);
  }
  return jsonParsed;
};

export const filterDataToBackEnd = (
  formObj: IGaeaAll,
  formValues: IterateAny
) => {
  const result: IterateAny = {};
  for (const key in formValues) {
    const visibleConditions = formObj[key]?.data.props.visibleConditions;
    if (visibleConditions && visibleConditions.length > 0) {
      const show = visibleConditions.every((el: ICondition) => {
        // 不同类型的条件处理器 只有一个条件先按且来写
        let handler = ConditionHandlers[el.componentType];
        if (!handler) {
          console.info('缺少条件处理器,使用默认的条件处理');
          handler = defaultHandler;
        }
        // 解决外面不传form的问题
        return handler(el, formValues?.[el.conditionName]);
      });
      if (show) {
        result[key] = formValues[key];
      }
    } else {
      result[key] = formValues[key];
    }
  }
  return result;
};

// 找到侧边展示的前三项
// 满足条件 text，不是明细里面的
export const findSummary = (
  result: { label: string; value: string }[],
  formJsonParsed: IGaeaAll,
  formValuesParsed: IterateAny,
  childs?: string[],
  permissionId?: string
) => {
  if (!childs || childs.length === null) return result;

  for (let i = 0; i < childs.length && result.length < 3; i++) {
    const instance: IGaeaInstance = formJsonParsed[childs[i]];
    // 可能存在之前拖动过的但是后面不支持的组件
    if (!instance) {
      continue;
    }
    const instanceType: string = instance.gaeaKey;
    const fieldName = instance.data.props.code;
    // 我发起的权限是全部
    let permission;
    if (permissionId) {
      permission = instance.data.props.bpmnPermission
        ? instance.data.props.bpmnPermission[permissionId]
        : null;
    } else {
      permission = null;
    }
    // 需要加上权限判断不是隐藏
    if (
      permission !== 'hide' &&
      !ComponentExtraProperties[instanceType]?.detailComponent &&
      fieldName &&
      !isEmptyExecptZero(formValuesParsed[fieldName]) &&
      instance.data.props.type
    ) {
      result.push({
        label: instance.data.props.name,
        value: parseTextValue(formValuesParsed[fieldName]),
      });
    }
    findSummary(
      result,
      formJsonParsed,
      formValuesParsed,
      instance.childs,
      permissionId
    );
  }
  return result;
};
